// pages/index/index.js
const app = getApp()

Page({
  data: {
    userInfo: null,
    familyInfo: null,
    dishes: [],
    todayMenu: [],
    orderStats: {
      pending: 0,
      cooking: 0,
      completed: 0
    },
    cartItemCount: 0,
    showLoginModal: false,
    // 家庭活动数据
    familyActivities: [],
    showActivityDetailModal: false,
    selectedActivity: null,
    isChef: false,
    // 推荐服务定时器
    recommendTimer: null,
    // 欢迎区域背景图片
    welcomeBgImage: null,
    // 问候语和每日一问
    greetingText: '欢迎回来',
    dailyQuestion: '今天想吃什么？',
    // 图标文件存在性检查
    iconExists: {
      star: false,
      celebration: false
    },

  },

  onLoad() {
    console.log('首页开始加载数据')
    
    // 检查登录状态，但不强制跳转
    if (app.globalData.isLoggedIn) {
      console.log('用户已登录，加载完整数据')
      this.loadFamilyInfo()
      this.loadDishesAndMenu()
      
      // 检查用户是否为厨师
      this.checkUserRole()
      
      // 延迟加载订单统计，确保云开发已初始化
      setTimeout(() => {
        this.loadOrderStats()
      }, 1000)
      
      // 设置定时刷新订单统计，每15秒检查一次
      this.orderStatsTimer = setInterval(() => {
        console.log('定时刷新订单统计...')
        this.loadOrderStats()
      }, 15000) // 15秒
    } else {
      console.log('用户未登录，仅加载公开数据')
      // 未登录用户只加载服务数据，不加载个人信息相关数据
      this.loadDishesAndMenu()
    }
    
    // 确保有服务数据，如果没有则直接加载默认数据
    setTimeout(() => {
      if (!this.data.dishes || this.data.dishes.length === 0) {
        console.log('onLoad: 延迟检查发现服务数据为空，直接加载默认数据')
        this.loadDishesAndMenu()
      }
    }, 500)
    
    this.loadCartCount()
    this.loadFamilyActivities()
    this.loadWelcomeBgImage()
    this.updateGreetingAndQuestion()
    
    // 检查图标文件是否存在
    this.checkIconFiles()
    
    // 启动推荐服务定时随机变化
    this.startRecommendTimer()
  },

  onUnload() {
    // 页面卸载时清理定时器
    if (this.data.recommendTimer) {
      this.stopRecommendTimer()
    }
    if (this.orderStatsTimer) {
      clearInterval(this.orderStatsTimer)
    }
    console.log('首页页面已卸载，定时器已清理')
  },

  onShow() {
    // 检查登录状态，但不强制跳转
    if (app.globalData.isLoggedIn) {
      console.log('用户已登录，加载完整数据')
      // 确保事件监听已设置
      this.setupEventListeners()
      
      this.loadCartCount()
                this.loadWelcomeBgImage()
      // 页面显示时更新数据
      this.setData({
        userInfo: app.globalData.userInfo,
        familyInfo: app.globalData.familyInfo,
        dishes: app.globalData.dishes
      })
      
      // 检查用户身份
      this.checkUserRole()
      
      // 如果服务数据为空，尝试重新加载
      if (!app.globalData.dishes || app.globalData.dishes.length === 0) {
        console.log('onShow: 服务数据为空，重新加载')
        this.loadDishesAndMenu()
      } else {
        // 重新生成推荐服务
        this.loadTodayMenu()
      }
      
      // 检查是否需要刷新订单统计
      if (app.globalData.needRefreshOrderStats) {
        this.loadOrderStats()
        app.globalData.needRefreshOrderStats = false
        console.log('首页订单统计已刷新')
      } else {
        // 正常刷新订单统计
        this.loadOrderStats()
      }
    } else {
      console.log('用户未登录，仅显示公开数据')
      // 未登录用户只显示服务数据
      this.setData({
        dishes: app.globalData.dishes
      })
      
      // 如果服务数据为空，尝试重新加载
      if (!app.globalData.dishes || app.globalData.dishes.length === 0) {
        console.log('onShow: 服务数据为空，重新加载')
        this.loadDishesAndMenu()
      }
    }
    
    // 确保有服务数据，如果没有则强制加载默认数据
    setTimeout(() => {
      if (!this.data.dishes || this.data.dishes.length === 0) {
        console.log('onShow: 延迟检查发现服务数据仍为空，强制加载默认数据')
        this.loadDishesAndMenu()
      }
    }, 1000)
    
    // 刷新家庭活动数据
    this.loadFamilyActivities()
    
    // 更新问候语和每日一问
    this.updateGreetingAndQuestion()
    
    // 启动推荐服务定时随机变化
    this.startRecommendTimer()
    
    // 初始化TabBar页面（检查并应用等待中的图标配置）
    app.initTabBarPage()
  },

  // 加载家庭信息
  loadFamilyInfo() {
    const familyInfo = app.globalData.familyInfo
    if (familyInfo) {
      this.setData({ familyInfo })
    }
  },

  // 加载推荐服务
  loadTodayMenu() {
    const dishes = app.globalData.dishes || []
    console.log('loadTodayMenu - 当前服务数据:', dishes)
    
    if (dishes.length === 0) {
      console.log('服务数据为空，推荐服务不显示')
      this.setData({ 
        todayMenu: []
      })
      return
    }
    console.log('xxxxxx',dishes)
    // 随机选择2道服务作为推荐服务
    const shuffled = dishes.sort(() => 0.5 - Math.random())
    const todayMenu = shuffled.slice(0, 4).map(dish => ({
      ...dish,
      available: dish.available !== undefined ? dish.available : true // 使用每个dish自身的available值
    }))
    
    console.log('生成推荐服务:', todayMenu)
    this.setData({ 
      todayMenu
    })
  },

  // 加载订单统计
  async loadOrderStats() {
    try {
      // 从云数据库加载订单统计
      const { orderService } = require('../../utils/cloud.js')
      
      // 需要传入userId来隔离用户订单
      if (!app.globalData.userInfo || !app.globalData.userInfo._id) {
        console.error('无法加载订单统计：用户信息缺失')
        this.setData({
          orderStats: { pending: 0, cooking: 0, completed: 0 }
        })
        return
      }
      
      const currentUserId = app.globalData.userInfo._id
      console.log('加载用户订单统计，用户ID:', currentUserId)
      
      // 从本地订单数据中过滤出当前用户的订单进行统计
      const orders = app.globalData.orders || []
      const userOrders = orders.filter(order => order.userId === currentUserId)
      
      const orderStats = {
        pending: userOrders.filter(order => order.status === 'pending').length,
        cooking: userOrders.filter(order => order.status === 'cooking').length,
        completed: userOrders.filter(order => order.status === 'completed').length
      }
      
      this.setData({ orderStats })
      console.log(`用户 ${currentUserId} 的订单统计加载成功:`, orderStats)
      console.log(`用户订单总数: ${userOrders.length}`)
    } catch (error) {
      console.error('加载订单统计失败:', error)
      // 出错时设置为0
      this.setData({
        orderStats: { pending: 0, cooking: 0, completed: 0 }
      })
    }
  },

  // 加载选择的服务数量
  loadCartCount() {
    // 从全局数据中获取选择的服务数量
    const cart = app.globalData.cart || []
    const cartItemCount = cart.reduce((sum, item) => sum + item.quantity, 0)
    
    this.setData({
      cartItemCount
    })
  },

  // 加载服务和菜单
  async loadDishesAndMenu() {
    try {
      // 从云数据库加载服务数据
      await this.loadDishesFromCloud()
      
      console.log('服务数据加载完成，共', app.globalData.dishes.length, '道菜')
    } catch (error) {
      console.error('加载服务数据失败:', error)
      // 设置空数据
      this.setData({
        dishes: []
      })
    }
  },

  // 从云数据库加载服务数据
  async loadDishesFromCloud() {
    try {
      console.log('从云数据库加载服务数据...')
      await app.syncDishesData()
      
      // 更新本地数据
      this.setData({
        dishes: app.globalData.dishes || []
      })
      
      // 生成推荐服务
      this.loadTodayMenu()
      
      console.log('云数据库服务数据加载完成，共', app.globalData.dishes.length, '道菜')
    } catch (error) {
      console.error('从云数据库加载服务数据失败:', error)
      // 设置空数据
      this.setData({
        dishes: []
      })
    }
  },

  // 切换到厨师模式
  switchToChef() {
    wx.navigateTo({
      url: '/pages/chef/dashboard/dashboard'
    })
  },

  // 选择服务
  orderDish(e) {
    const dish = e.currentTarget.dataset.dish
    if (!dish.available) {
      // wx.showToast({
      //   title: '该服务暂不可用',
      //   icon: 'none'
      // })
      return
    }

    // 跳转到服务选择页面并显示服务详情
    wx.switchTab({
      url: '/pages/dishes/dishes',
      success: () => {
        // 通过全局数据传递服务信息，让服务选择页面自动显示详情
        app.globalData.dishToShowDetail = dish
        // 触发事件通知服务选择页面
        if (app.globalData.eventBus) {
          app.globalData.eventBus.emit('showDishDetail', dish)
        }
      }
    })
  },

  // 查看选择的服务
  viewCart() {
    wx.switchTab({
      url: '/pages/cart/cart'
    })
  },

  // 查看安排记录
  viewOrders() {
    wx.switchTab({
      url: '/pages/orders/orders'
    })
  },

  // 查看个人资料
  viewProfile() {
    wx.switchTab({
      url: '/pages/profile/profile'
    })
  },

  // 去点餐
  browseDishes() {
    wx.switchTab({
      url: '/pages/dishes/dishes'
    })
  },

  // 关闭登录弹框
  onLoginModalClose() {
    this.setData({
      showLoginModal: false
    })
  },

  // 登录成功回调
  onLoginSuccess() {
    console.log('登录成功，刷新页面数据')
    // 登录成功后刷新页面数据
    this.loadFamilyInfo()
    this.loadOrderStats()
    this.loadCartCount()
    
    // 更新页面数据
    this.setData({
      userInfo: getApp().globalData.userInfo,
      familyInfo: getApp().globalData.familyInfo
    })
  },

  // 显示登录弹框（供其他页面调用）
  showLoginModal() {
    this.setData({
      showLoginModal: true
    })
  },

  // 调试：查看云数据库中的所有订单
  async debugAllOrders() {
    try {
      const { orderService } = require('../../utils/cloud.js')
      const result = await orderService.getAllOrders()
      
      if (result.success) {
        console.log('=== 云数据库订单调试信息 ===')
        console.log('当前用户ID:', app.globalData.userInfo?._id)
        console.log('当前家庭ID:', app.globalData.familyInfo?._id)
        console.log('云数据库订单总数:', result.data.length)
        console.log('所有订单详情:', result.data)
        console.log('=== 调试信息结束 ===')
        
        // 自动修复没有familyId的订单
        if (app.globalData.familyInfo?._id) {
          await this.fixOrdersWithoutFamilyId(result.data, app.globalData.familyInfo._id)
        }
      }
    } catch (error) {
      console.error('调试订单信息失败:', error)
    }
  },

  // 修复没有familyId的订单
  async fixOrdersWithoutFamilyId(orders, familyId) {
    try {
      const { orderService } = require('../../utils/cloud.js')
      const ordersToFix = orders.filter(order => !order.familyId)
      
      if (ordersToFix.length > 0) {
        console.log(`发现 ${ordersToFix.length} 个订单需要修复familyId`)
        
        for (const order of ordersToFix) {
          const fixResult = await orderService.fixOrderFamilyId(order._id, familyId)
          if (fixResult.success) {
            console.log(`订单 ${order._id} 的familyId修复成功`)
          } else {
            console.error(`订单 ${order._id} 的familyId修复失败`)
          }
        }
        
        // 修复完成后刷新订单统计
        this.loadOrderStats()
      }
    } catch (error) {
      console.error('修复订单familyId失败:', error)
    }
  },
  
  // 设置事件监听
  setupEventListeners() {
    // 监听订单状态变化事件
    if (app.globalData.eventBus) {
      // 先移除可能存在的监听器，避免重复
      app.globalData.eventBus.off('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      app.globalData.eventBus.on('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      console.log('✅ 首页已设置订单状态变化事件监听')
      
      // 监听家庭活动变化事件
      app.globalData.eventBus.off('familyActivitiesChanged', this.handleFamilyActivitiesChange.bind(this))
      app.globalData.eventBus.on('familyActivitiesChanged', this.handleFamilyActivitiesChange.bind(this))
      console.log('✅ 首页已设置家庭活动变化事件监听')
      
      // 监听欢迎区域背景更新事件
      app.globalData.eventBus.off('updateWelcomeBackground', this.handleWelcomeBackgroundUpdate.bind(this))
      app.globalData.eventBus.on('updateWelcomeBackground', this.handleWelcomeBackgroundUpdate.bind(this))
      console.log('✅ 首页已设置欢迎区域背景更新事件监听')
      

    } else {
      console.error('❌ 事件总线未初始化，无法设置事件监听')
      // 延迟重试
      setTimeout(() => {
        this.setupEventListeners()
      }, 500)
    }
  },
  
  // 处理订单状态变化事件
  handleOrderStatusChange(data) {
    console.log('首页收到订单状态变化通知:', data)
    
    // 检查是否是当前用户的订单
    const currentUserId = app.globalData.userInfo?._id
    if (data.userId && data.userId !== currentUserId) {
      console.log('订单不属于当前用户，忽略通知')
      return
    }
    
    // 延迟1秒刷新，确保云数据库更新完成
    setTimeout(async () => {
      console.log('延迟刷新订单统计...')
      await this.loadOrderStats()
    }, 1000)
    
    // 显示提示
    wx.showToast({
      title: '订单状态已更新',
      icon: 'success',
      duration: 1500
    })
  },

  // 处理家庭活动变化事件
  handleFamilyActivitiesChange() {
    console.log('首页收到家庭活动变化通知，开始刷新数据...')
    
    // 延迟500ms刷新，确保云数据库更新完成
    setTimeout(async () => {
      console.log('延迟刷新家庭活动...')
      await this.loadFamilyActivities()
    }, 500)
    
    // 显示提示
    wx.showToast({
      title: '活动已更新',
      icon: 'success',
      duration: 1500
    })
  },

  // 处理欢迎区域背景更新事件
  handleWelcomeBackgroundUpdate(imageUrl) {
    console.log('首页收到欢迎区域背景更新通知:', imageUrl)
    
    // 立即更新背景
    this.setData({
      welcomeBgImage: imageUrl
    })
    
    // 显示提示
    wx.showToast({
      title: '背景已更新',
      icon: 'success',
      duration: 1500
    })
  },



  onUnload() {
    // 页面卸载时清除定时器
    if (this.orderStatsTimer) {
      clearInterval(this.orderStatsTimer)
      this.orderStatsTimer = null
      console.log('首页订单统计定时器已清理')
    }
  },

  // 加载家庭活动
  async loadFamilyActivities() {
    try {
      const { activityService } = require('../../utils/cloud.js')
      
      // 使用默认家庭ID加载活动
      const familyId = 'xiaoweichufang'
      const result = await activityService.getFamilyActivities(familyId)
      
      if (result.success && result.data) {
        // 格式化活动数据
        const activities = result.data.map(activity => ({
          ...activity,
          id: activity._id,
          date: this.formatActivityDate(activity.planDate),
          statusText: this.getStatusText(activity.status)
        }))
        
        this.setData({ familyActivities: activities })
        console.log('家庭活动加载完成，共', activities.length, '个活动')
      } else {
        console.log('加载家庭活动失败:', result.error)
        this.setData({ familyActivities: [] })
      }
    } catch (error) {
      console.error('加载家庭活动时发生错误:', error)
      this.setData({ familyActivities: [] })
    }
  },

  // 格式化活动日期
  formatActivityDate(dateString) {
    if (!dateString) return '待定'
    
    const date = new Date(dateString)
    const now = new Date()
    const diffTime = date.getTime() - now.getTime()
    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24))
    
    if (diffDays === 0) return '今天'
    if (diffDays === 1) return '明天'
    if (diffDays === -1) return '昨天'
    if (diffDays > 0 && diffDays <= 7) return `本周${['日', '一', '二', '三', '四', '五', '六'][date.getDay()]}`
    if (diffDays > 7) return `${date.getMonth() + 1}月${date.getDate()}日`
    
    return dateString
  },

  // 获取状态文本
  getStatusText(status) {
    const statusMap = {
      'pending': '待准备',
      'in-progress': '准备中',
      'completed': '已完成',
      'cancelled': '已取消'
    }
    return statusMap[status] || '未知'
  },

  // 查看活动详情
  viewActivityDetail(e) {
    const activity = e.currentTarget.dataset.activity
    console.log('查看活动详情:', activity)
    
    this.setData({
      showActivityDetailModal: true,
      selectedActivity: activity
    })
  },

  // 隐藏活动详情弹框
  hideActivityDetailModal() {
    this.setData({ showActivityDetailModal: false })
  },

  // 检查用户身份
  checkUserRole() {
    const userInfo = app.globalData.userInfo
    const familyInfo = app.globalData.familyInfo
    
    if (userInfo && familyInfo) {
      // 检查用户是否为家庭创建者、厨师或管理员
      // 这些用户都有编辑活动的权限
      const isChef = userInfo._id === familyInfo.createdBy || 
                     (familyInfo.chefs && familyInfo.chefs.includes(userInfo._id)) ||
                     userInfo.role === 'chef' ||
                     userInfo.role === 'admin'
      
      this.setData({ isChef })
      console.log('用户身份检查:', { 
        isChef, 
        userId: userInfo._id, 
        userRole: userInfo.role,
        familyCreator: familyInfo.createdBy,
        isFamilyCreator: userInfo._id === familyInfo.createdBy,
        isChefMember: familyInfo.chefs && familyInfo.chefs.includes(userInfo._id)
      })
    }
  },

  // 从详情弹框编辑活动
  editActivityFromDetail() {
    this.hideActivityDetailModal()
    // 跳转到活动管理页面
    wx.navigateTo({
      url: '/pages/chef/activities/activities'
    })
  },

  // 编辑活动
  editActivity(e) {
    const activity = e.currentTarget.dataset.activity
    console.log('编辑活动:', activity)
    
    wx.showModal({
      title: '编辑活动',
      content: '这个功能正在开发中，敬请期待！',
      showCancel: false,
      confirmText: '知道了'
    })
  },

  // 完成活动
  completeActivity(e) {
    const activity = e.currentTarget.dataset.activity
    console.log('完成活动:', activity)
    
    wx.showModal({
      title: '完成活动',
      content: `确认完成"${activity.title}"吗？`,
      success: (res) => {
        if (res.confirm) {
          // 更新活动状态
          const activities = this.data.familyActivities
          const activityIndex = activities.findIndex(a => a.id === activity.id)
          
          if (activityIndex !== -1) {
            activities[activityIndex].status = 'completed'
            activities[activityIndex].statusText = '已完成'
            
            this.setData({
              familyActivities: activities
            })
            
            wx.showToast({
              title: '活动已完成',
              icon: 'success'
            })
          }
        }
      }
    })
  },

  // 显示添加活动弹窗
  showAddActivityModal() {
    wx.showModal({
      title: '添加新活动',
      content: '这个功能正在开发中，敬请期待！',
      showCancel: false,
      confirmText: '知道了'
    })
  },

  // 启动推荐服务定时随机变化
  startRecommendTimer() {
    // 清除之前的定时器
    if (this.data.recommendTimer) {
      clearInterval(this.data.recommendTimer)
    }
    
    // 设置新的定时器，每30秒随机更新推荐服务
    const timer = setInterval(() => {
      this.randomizeRecommendDishes()
    }, 60000) // 30秒
    
    this.setData({
      recommendTimer: timer
    })
    
    console.log('推荐服务定时器已启动，每30秒随机更新')
  },

  // 随机更新推荐服务
  randomizeRecommendDishes() {
    const dishes = app.globalData.dishes || []
    if (dishes.length === 0) {
      console.log('服务数据为空，无法随机更新推荐服务')
      return
    }
    
    // 随机选择2道服务作为推荐服务
    const shuffled = dishes.sort(() => 0.5 - Math.random())
    const todayMenu = shuffled.slice(0, 4).map(dish => ({
      ...dish,
      available: dish.available !== undefined ? dish.available : true // 使用每个dish自身的available值
    }))
    
    console.log('定时随机更新推荐服务:', todayMenu)
    this.setData({ 
      todayMenu
    })
    
    // 显示提示信息
    // wx.showToast({
    //   title: '推荐服务已更新',
    //   icon: 'none',
    //   duration: 1500
    // })
  },

  // 停止推荐服务定时器
  stopRecommendTimer() {
    if (this.data.recommendTimer) {
      clearInterval(this.data.recommendTimer)
      this.setData({
        recommendTimer: null
      })
      console.log('推荐服务定时器已停止')
    }
  },

  // 加载欢迎区域背景图片
  async loadWelcomeBgImage() {
    try {
      // 优先从云端加载背景
      await this.loadBackgroundFromCloud()
      
      // 如果云端没有，则从本地加载
      if (!this.data.welcomeBgImage) {
        const localBgImage = wx.getStorageSync('welcomeBgImage')
        if (localBgImage) {
          console.log('从本地存储加载背景图片:', localBgImage)
          this.setData({
            welcomeBgImage: localBgImage
          })
        } else {
          console.log('未设置背景图片，使用默认样式')
          this.setData({
            welcomeBgImage: null
          })
        }
      }
    } catch (error) {
      console.error('加载背景图片失败:', error)
      // 降级到本地存储
      const localBgImage = wx.getStorageSync('welcomeBgImage')
      if (localBgImage) {
        this.setData({
          welcomeBgImage: localBgImage
        })
      } else {
        this.setData({
          welcomeBgImage: null
        })
      }
    }
  },

  // 从云端加载背景
  async loadBackgroundFromCloud() {
    try {
      // 调用云函数获取当前背景
      const result = await wx.cloud.callFunction({
        name: 'getCurrentBackground'
      })
      
      if (result.result && result.result.success && result.result.data) {
        console.log('从云端加载背景成功:', result.result.data.imageUrl)
        
        this.setData({
          welcomeBgImage: result.result.data.imageUrl
        })
        
        // 同步到本地存储
        wx.setStorageSync('welcomeBgImage', result.result.data.imageUrl)
      }
    } catch (error) {
      console.error('从云端加载背景失败:', error)
      // 云函数未部署时，静默失败，使用本地存储
      console.log('云函数未部署，使用本地存储')
    }
  },

  // 设置欢迎区域背景图片
  setWelcomeBgImage(imageUrl) {
    try {
      // 保存到本地存储
      wx.setStorageSync('welcomeBgImage', imageUrl)
      
      // 更新页面数据
      this.setData({
        welcomeBgImage: imageUrl
      })
      
      console.log('欢迎区域背景图片已设置:', imageUrl)
      
      wx.showToast({
        title: '背景图片已设置',
        icon: 'success'
      })
    } catch (error) {
      console.error('设置欢迎区域背景图片失败:', error)
      wx.showToast({
        title: '设置失败',
        icon: 'error'
      })
    }
  },

  // 清除欢迎区域背景图片
  clearWelcomeBgImage() {
    try {
      // 从本地存储移除
      wx.removeStorageSync('welcomeBgImage')
      
      // 更新页面数据
      this.setData({
        welcomeBgImage: null
      })
      
      console.log('欢迎区域背景图片已清除')
      
      wx.showToast({
        title: '背景图片已清除',
        icon: 'success'
      })
    } catch (error) {
      console.error('清除欢迎区域背景图片失败:', error)
      wx.showToast({
        title: '清除失败',
        icon: 'error'
      })
    }
  },







  // 浏览服务
  browseDishes() {
    wx.switchTab({
      url: '/pages/dishes/dishes'
    })
  },

  // 查看预约
  viewOrders() {
    wx.switchTab({
      url: '/pages/orders/orders'
    })
  },

  // 查看个人中心
  viewProfile() {
    wx.switchTab({
      url: '/pages/profile/profile'
    })
  },

  // 更新问候语和每日一问
  updateGreetingAndQuestion() {
    const now = new Date()
    const hour = now.getHours()
    
    // 根据时间生成问候语
    let greeting = ''
    if (hour >= 5 && hour < 12) {
      greeting = '早上好'
    } else if (hour >= 12 && hour < 18) {
      greeting = '下午好'
    } else if (hour >= 18 && hour < 22) {
      greeting = '晚上好'
    } else {
      greeting = '夜深了'
    }
    
    // 每日一问数组
    const dailyQuestions = [
      '今天想吃什么？',
      '有什么特别想尝试的吗？',
      '今天心情怎么样？',
      '想和家人一起做什么？',
      '有什么新的计划吗？',
      '今天想放松一下吗？',
      '有什么想分享的吗？',
      '今天想学点什么？',
      '想尝试新的体验吗？',
      '今天想怎么度过？'
    ]
    
    // 根据日期选择问题（每天不同）
    const dayOfYear = Math.floor((now - new Date(now.getFullYear(), 0, 0)) / (1000 * 60 * 60 * 24))
    const questionIndex = dayOfYear % dailyQuestions.length
    const question = dailyQuestions[questionIndex]
    
    this.setData({
      greetingText: greeting,
      dailyQuestion: question
    })
    
    console.log('问候语和每日一问已更新:', { greeting, question, hour })
  },

  // 检查图标文件是否存在
  checkIconFiles() {
    const iconPaths = {
      star: '/images/icons/star.png',
      celebration: '/images/icons/celebration.png'
    }
    
    const iconExists = {}
    
    // 检查每个图标文件
    Object.keys(iconPaths).forEach(iconName => {
      const iconPath = iconPaths[iconName]
      
      // 使用wx.getFileInfo检查文件是否存在
      wx.getFileInfo({
        filePath: iconPath,
        success: () => {
          iconExists[iconName] = true
          this.setData({
            [`iconExists.${iconName}`]: true
          })
        },
        fail: () => {
          iconExists[iconName] = false
          this.setData({
            [`iconExists.${iconName}`]: false
          })
          console.log(`图标文件不存在: ${iconPath}`)
        }
      })
    })
  }

}) 